const gaiaModule = require('../../utils/gaiaManager.js')
const gaiaManager = gaiaModule.gaiaManager
const VendorID = gaiaModule.VendorID
const bluetoothManager = require('../../utils/bluetooth.js')

  

// 从gaiaManager获取GaiaCommand常量
const GaiaCommand = gaiaModule.GaiaCommand || {
  GET_GAIA_VERSION: 0x00,
  GET_APPLICATION_VERSION: 0x05,
  GET_SERIAL_NUMBER: 0x03,
  GET_VARIANT_NAME: 0x04,
  GET_DEVICE_BLUETOOTH_ADDRESS: 0x10,  // 新增：蓝牙地址命令
  GET_SYSTEM_INFORMATION: 0x11,
  GET_SUPPORTED_BATTERIES: 0x00,
  GET_BATTERY_LEVELS: 0x01
}

// Vendor ID已从gaiaManager模块导入

Page({
  data: {
    deviceId: '',
    deviceName: '',
    loading: false,
    error: null,
    deviceInfo: {
      connected: false,
      name: '',
      variantName: null,
      hasBatteryLevels: false,
      batteryLevels: {
        device: null,
        left: null,
        right: null,
        case: null
      },
      hasSerialNumbers: false,
      serialNumber: null,
      serialNumberLeft: null,
      serialNumberRight: null,
      showSingleSerialNumber: false,
      hasVersions: false,
      bluetoothAddress: null,
      applicationVersion: null,
      applicationBuildId: null,
      gaiaVersion: null,
      hasStates: false,
      state: '未连接',
      isCharging: false,
      secondarySerialNumber: null,
      supportedBatteries: [],
      bleData: null,  // 新增：BLE数据
      parseResults: []  // 新增：解析结果列表
    }
  },

  // 页面加载时
  onLoad(options) {
     this.deviceId = options.deviceId
    this.deviceName = options.deviceName
    
    // 标记是从设备发现页面进入的
    this.fromDiscovery = true
    
    // 页面加载时不立即加载设备信息，等待页面显示时再处理
  },

  // 页面显示时
  onShow() {
    // 设置设备信息页面的GAIA响应回调
    gaiaManager.setOnCommandResponse((commandId, payload, type, vendorId) => {
      console.log('📋 [设备信息页面] 收到GAIA响应:', { 
        commandId: `0x${commandId.toString(16).padStart(2, '0')}`, 
        payloadLength: payload.length,
        type,
        vendorId: `0x${vendorId.toString(16).padStart(4, '0')}`
      })
      
      // 处理设备信息相关的命令响应
      if (vendorId === 0x001D) { // QTIL_V3
        switch (commandId) {
          case 0x00: // GET_GAIA_VERSION
            console.log('📋 [设备信息页面] GAIA版本响应')
            this.handleGaiaVersionResponse(payload)
            break
          case 0x05: // GET_APPLICATION_VERSION
            console.log('📋 [设备信息页面] 应用版本响应')
            this.handleApplicationVersionResponse(payload)
            break
          case 0x03: // GET_SERIAL_NUMBER
            console.log('📋 [设备信息页面] 序列号响应')
            this.handleSerialNumberResponse(payload)
            break
          case 0x04: // GET_VARIANT_NAME
            console.log('📋 [设备信息页面] 变体名称响应')
            this.handleVariantNameResponse(payload)
            break
          case 0x11: // GET_SYSTEM_INFORMATION
            console.log('📋 [设备信息页面] 系统信息响应')
            this.handleSystemInformationResponse(payload)
            break
          case 0x01: // GET_BATTERY_LEVELS
            console.log('📋 [设备信息页面] 电池电量响应')
            this.handleBatteryLevelsResponse(payload)
            break
          // 其他设备信息相关命令...
        }
      }
    })

    // 设置设备信息页面的BLE数据回调
    gaiaManager.setBleDataCallback((data) => {
      console.log('📋 [设备信息页面] 收到BLE原始数据:', data)
      this.handleBleData(data)
    })
     
    // 尝试从本地存储获取已连接设备信息
    this.loadConnectedDeviceInfo()
    
    // 检查是否有设备ID
    if (!this.deviceId) {
       this.setData({
        error: '没有设备ID，请先连接设备',
        loading: false
      })
      return
    }
    
    // 检查设备是否仍然连接（避免在断开连接后尝试重新连接）
    const connectedDeviceInfo = wx.getStorageSync('connectedDeviceInfo')
    if (!connectedDeviceInfo) {
      // 设备信息已被清理，说明设备已断开连接
      this.setData({
        error: '设备已断开连接',
        loading: false,
        'deviceInfo.connected': false
      })
      return
    }
    
    // 根据进入方式决定数据获取策略
    const cachedInfo = wx.getStorageSync('connectedDeviceInfo')
    const fetchedFlag = wx.getStorageSync('deviceInfoFetched')

    if (this.fromDiscovery) {
      // 从设备发现页面进入：完整获取数据
      console.log('📋 [设备信息页面] 从设备发现页面进入，完整获取数据')
      this.loadDeviceInfo()
      this.fromDiscovery = false // 重置标记
    } else if (cachedInfo && fetchedFlag) {
      // 从其他页面切换进入：使用缓存 + 刷新电池
      console.log('📋 [设备信息页面] 页面切换进入，使用缓存数据')
      this.setData({
        'deviceInfo.connected': true,
        'deviceInfo.name': cachedInfo.name || this.deviceName || '',
        'deviceInfo.variantName': cachedInfo.variantName || null,
        'deviceInfo.serialNumber': cachedInfo.serialNumber || null,
        'deviceInfo.bluetoothAddress': cachedInfo.bluetoothAddress || this.deviceId || null,
        'deviceInfo.applicationVersion': cachedInfo.applicationVersion || null,
        'deviceInfo.applicationBuildId': cachedInfo.applicationBuildId || null,
        'deviceInfo.gaiaVersion': cachedInfo.gaiaVersion || null,
        'deviceInfo.systemInformation': cachedInfo.systemInformation || null,
        'deviceInfo.hasVersions': !!(cachedInfo.applicationVersion || cachedInfo.gaiaVersion),
        'deviceInfo.hasSerialNumbers': !!cachedInfo.serialNumber,
        'deviceInfo.state': '已连接'
      })
      // 仅刷新电池电量
      this.refreshBatteryLevels()
    } else {
      // 首次进入或无缓存：完整拉取一次并写入缓存
      console.log('📋 [设备信息页面] 首次进入或无缓存，完整获取数据')
      this.loadDeviceInfo()
    }
    console.log("执行11111111")
  },

  // 页面隐藏时
  onHide() {
    // 清除设备信息页面的回调，让其他页面可以设置回调
    gaiaManager.setOnCommandResponse(null)
    gaiaManager.setBleDataCallback(null)
    
    // 注意：页面隐藏时不清除缓存，因为可能在页面间切换
    // 缓存清除只在页面卸载时进行
  },

  // 从本地存储加载已连接设备信息
  loadConnectedDeviceInfo() {
    try {
      // 尝试从存储中获取已连接设备信息
      const connectedDeviceInfo = wx.getStorageSync('connectedDeviceInfo')
      const lastConnectedDevice = wx.getStorageSync('lastConnectedDevice')
      
      if (connectedDeviceInfo && lastConnectedDevice) {
        // 更新页面数据
        this.deviceId = lastConnectedDevice
        this.deviceName = connectedDeviceInfo.name || '未知设备'
        
        // 更新UI状态
        this.setData({
          'deviceInfo.connected': true,
          'deviceInfo.name': this.deviceName,
          'deviceInfo.bluetoothAddress': this.deviceId,
          'deviceInfo.state': '已连接'
        })
      } else {
        // 设备信息不存在，清空设备ID
        this.deviceId = null
        this.deviceName = null
        
        // 更新UI状态为未连接
        this.setData({
          'deviceInfo.connected': false,
          'deviceInfo.name': '',
          'deviceInfo.bluetoothAddress': '',
          'deviceInfo.state': '未连接'
        })
      }
    } catch (error) {
      console.error('加载设备信息失败:', error)
      // 出错时也清空设备ID
      this.deviceId = null
      this.deviceName = null
    }
  },

  // 页面卸载时
  onUnload() {
     // 移除BLE数据监听器
    if (this.bleDataListener) {
      gaiaManager.removeBleDataListener(this.bleDataListener)
      this.bleDataListener = null
    }
    // 移除命令响应监听器
    if (this.commandResponseListener) {
      gaiaManager.removeCommandResponseListener(this.commandResponseListener)
      this.commandResponseListener = null
    }
    // 清理响应去重缓存
    if (this.processedResponses) {
      this.processedResponses.clear()
      this.processedResponses = null
    }
    // 清理连接状态
    if (gaiaManager.isConnected) {
      gaiaManager.isConnected = false
    }
    
    // 清除设备信息缓存
    this.clearDeviceInfoCache()
  },

  // 判断是否是升级相关命令
  isUpgradeCommand(commandId, vendorId) {
    // 检查是否在升级状态
    if (gaiaManager.upgradeState && gaiaManager.upgradeState !== gaiaManager.UpgradeState.IDLE) {
      
      // 在升级状态下，以下命令被认为是升级相关命令
      if (vendorId === 0x001D) { // QTIL_V3
        if (commandId === 0x00 || // V1_UPGRADE_CONNECT
            commandId === 0x01 || // V1_UPGRADE_DISCONNECT  
            commandId === 0x02 || // V1_UPGRADE_CONTROL
            commandId === 0x04) { // V1_SET_DATA_ENDPOINT_MODE
          return true
        }
      }
    }
    
    return false
  },

  // 判断是否是升级相关BLE数据
  isUpgradeBleData(bleData) {
    // 检查是否在升级状态
    if (gaiaManager.upgradeState && gaiaManager.upgradeState !== gaiaManager.UpgradeState.IDLE) {
      
      // 解析BLE数据，检查是否是升级相关命令
      if (bleData && bleData.value) {
        const hexData = bleData.value
        // 检查是否是QTIL_V3 (0x001d) 的升级相关命令
        if (hexData.startsWith('001d') && hexData.length >= 6) {
          const commandId = parseInt(hexData.substring(4, 6), 16)
          if (commandId === 0x00 || // V1_UPGRADE_CONNECT
              commandId === 0x01 || // V1_UPGRADE_DISCONNECT  
              commandId === 0x02 || // V1_UPGRADE_CONTROL
              commandId === 0x04) { // V1_SET_DATA_ENDPOINT_MODE
            return true
          }
        }
      }
    }
    
    return false
  },

  // 加载设备信息
  async loadDeviceInfo() {
    try {
      this.setData({
        loading: true,
        error: null
      })

      // 先建立GAIA连接
      const connectionResult = await this.setupGaiaConnection()
      if (!connectionResult.success) {
        throw new Error(connectionResult.error || '连接设备失败')
      }
       // 连接成功后，获取设备数据
      await this.fetchDeviceData()
      
    } catch (error) {
       this.setData({
        error: error.message || '加载设备信息失败',
        loading: false
      })
    }
  },

  // 建立GAIA连接
  async setupGaiaConnection() {
    try {
       
      // 设置设备ID
      gaiaManager.setDeviceId(this.deviceId)
      
      // 连接设备
      const result = await gaiaManager.connect()
      if (!result.success) {
        throw new Error(result.error || '连接失败')
      }
      
      // 更新连接状态
      this.setData({
        'deviceInfo.connected': true,
        'deviceInfo.name': this.deviceName,
        'deviceInfo.bluetoothAddress': this.deviceId,
        'deviceInfo.state': '已连接'
      })
      
       return { success: true }
      
    } catch (error) {
       // 更新连接状态
      this.setData({
        'deviceInfo.connected': false,
        'deviceInfo.state': '连接失败'
      })
      return { success: false, error: error.message }
    }
  },

  // 获取设备数据 - 参考安卓逻辑实现
  async fetchDeviceData() {
    try {
      // 检查连接状态
      if (!gaiaManager.isConnected) {
        throw new Error('设备未连接')
      }
      
      // 添加BLE数据监听器（不覆盖全局回调）
      this.bleDataListener = (bleData) => {
         
        // 🔧 过滤升级相关的BLE数据，避免干扰升级过程
        if (this.isUpgradeBleData(bleData)) {
           return
        }
        this.handleBleData(bleData)
      }
      gaiaManager.addBleDataListener(this.bleDataListener)
       
      // 添加命令响应监听器（不覆盖全局回调）
      this.commandResponseListener = (commandId, payload, type, vendorId) => {
        // 🔧 过滤升级相关命令，避免干扰升级过程
        if (this.isUpgradeCommand(commandId, vendorId)) {
           return
        }
        console.log("接收11111111",commandId, payload, type, vendorId)
        this.handleDeviceData(commandId, payload, type, vendorId)
      }
      gaiaManager.addCommandResponseListener(this.commandResponseListener)
      
      // ✅ 直接获取设备电池电量（简化流程）
      // 1. 设备的电池电量 (GET_BATTERY_LEVELS)
      // 2. 设备的序列号 (GET_SERIAL_NUMBER) 
      // 3. 设备固件的版本号 (GET_APPLICATION_VERSION)
      // 4. GAIA 协议版本 (GET_GAIA_VERSION)
      // 5. 设备的当前状态 (GET_CHARGER_STATUS)
      const commands = [
        { command: GaiaCommand.GET_GAIA_VERSION, name: 'GAIA协议版本', vendor: 'V3' },
        { command: GaiaCommand.GET_APPLICATION_VERSION, name: '设备固件版本', vendor: 'V3' },
        { command: GaiaCommand.GET_SERIAL_NUMBER, name: '设备序列号', vendor: 'V1V2' },
        { command: GaiaCommand.GET_BATTERY_LEVELS, name: '设备电池电量', vendor: 'V3' }
      ]
      
      // 发送所有命令
      for (let i = 0; i < commands.length; i++) {
        const { command, name, vendor } = commands[i]
        try {
          console.log('发送命令22222222222222:', commands[i].name)
          
          // 特殊处理电池电量命令，需要发送电池类型参数
          if (command === GaiaCommand.GET_BATTERY_LEVELS) {
            // 发送单设备电池类型查询
            await gaiaManager.fetchBatteryInfo([0]) // Battery.SINGLE_DEVICE = 0
          } else {
            // 其他命令不需要payload
            await gaiaManager.sendCommand(command, [])
          }
          
          // 等待响应，避免命令冲突
          await new Promise(resolve => setTimeout(resolve, 200))
          
        } catch (error) {
          // 继续发送下一个命令，不中断整个流程
        }
      }       
      // 获取电池电量
      //  console.log('1. 获取支持的电池类型...')
      //  const supportedResult = await gaiaManager.sendCommand(GaiaCommand.GET_SUPPORTED_BATTERIES)
      //  console.log('支持电池类型响应:', supportedResult)
      // // 等待一段时间再发送下一个命令
      // await new Promise(resolve => setTimeout(resolve, 100))
      // 获取设备支持的电池类型信息
      // 此命令用于查询设备支持哪些类型的电池，如单设备、左耳、右耳、充电盒等
      // 返回的数据包含设备支持的所有电池类型列表
      // const serialResult =  await gaiaManager.sendCommand(GaiaCommand.GET_SUPPORTED_BATTERIES, [])
      // console.log(serialResult.parsedData,"//////////////////////",GaiaCommand.GET_SUPPORTED_BATTERIES)







      // if (!serialResult.success) {
      //   console.warn('获取序列号失败:', serialResult.error)
      // }
      
      // console.log('设备数据获取完成')
      
      // 更新加载状态
      this.setData({
        loading: false
      })

      // 标记已完成一次完整信息获取（用于缓存控制）
      wx.setStorageSync('deviceInfoFetched', true)
      
    } catch (error) {
       this.setData({
        error: error.message || '获取设备数据失败',
        loading: false
      })
    }
  },

  // 仅刷新电池电量（切换时调用）
  async refreshBatteryLevels() {
    try {
      if (!gaiaManager.isConnected) {
        // 若未连接，尝试使用已知deviceId建立会话，但不强制
        if (this.deviceId) {
          gaiaManager.setDeviceId(this.deviceId)
          await gaiaManager.connect().catch(() => null)
        }
      }
      if (!gaiaManager.isConnected) {
        return
      }
      // 发送电池电量获取命令（单设备）
      await gaiaManager.fetchBatteryInfo([0])
    } catch (e) {
      // 忽略刷新错误，避免打断页面交互
    }
  },

  // 🚀 处理BLE数据 - 参考安卓逻辑实现发送值与返回值的对应关系
  handleBleData(bleValue) {
    try {
       
      // 更新页面数据，显示原始BLE数据
      this.setData({
        'deviceInfo.bleData': {
          value: bleValue.value,
          commandId: bleValue.id,
          timestamp: new Date().toLocaleTimeString()
        }
      })
      
      // 根据命令ID解析不同的设备信息
      this.parseBleDataByCommand(bleValue)
      
    } catch (error) {
     }
  },

  // 根据命令ID解析BLE数据 - 参考安卓逻辑实现发送值与返回值的对应关系
  parseBleDataByCommand(bleValue) {
    try {
      const { value, id: commandId } = bleValue
      
      
    } catch (error) {
       this.addParseResult(`❌ BLE数据解析失败: ${error.message}`)
    }
  },

  

  // 十六进制字符串转字节数组
  hexToBytes(hex) {
    const bytes = []
    for (let i = 0; i < hex.length; i += 2) {
      bytes.push(parseInt(hex.substring(i, i + 2), 16))
    }
    return bytes
  },

  // 解析V1V2插件命令
  parseV1V2Command(commandId, payload) {
      switch (commandId) {
      case 0x00: // GET_GAIA_VERSION
        this.parseGaiaVersion(payload)
        break
      case 0x05: // GET_APPLICATION_VERSION
        this.parseApplicationVersion(payload)
        break
      case 0x03: // GET_SERIAL_NUMBER
        this.parseSerialNumber(payload)
        break
      case 0x04: // GET_VARIANT_NAME
        this.parseVariantName(payload)
        break
      case 0x10: // GET_DEVICE_BLUETOOTH_ADDRESS
        this.parseBluetoothAddress(payload)
        break
      case 0x11: // GET_SYSTEM_INFORMATION
        this.parseSystemInformation(payload)
        break
      default:
         this.addParseResult(`未知V1V2命令: 0x${commandId.toString(16).padStart(2, '0')}`)
    }
  },

  // 解析V3插件命令
  parseV3Command(commandId, payload) {
    switch (commandId) {
      case 0x00: // 可能是GET_GAIA_VERSION或GET_SUPPORTED_BATTERIES
        // ✅ 修复：根据payload内容智能判断命令类型
        if (payload && payload.length === 1 && payload[0] >= 1 && payload[0] <= 5) {
          // GAIA版本响应：单个字节版本号(1-5)
          this.parseGaiaVersion(payload)
        } else if (payload && payload.length >= 1 && payload.every(b => b >= 0 && b <= 3)) {
          // 电池类型响应：多个字节且都在0-3范围内
          this.parseSupportedBatteries(payload)
        } else {
          // 默认尝试解析为GAIA版本
          this.parseGaiaVersion(payload)
        }
        break
      case 0x01: // GET_BATTERY_LEVELS
        this.parseBatteryLevels(payload)
        break
      case 0x02: // GET_CHARGER_STATUS
        this.parseChargerStatus(payload)
        break
      case 0x05: // GET_APPLICATION_VERSION
        this.parseApplicationVersion(payload)
        break
      case 0x03: // GET_SERIAL_NUMBER
        this.parseSerialNumber(payload)
        break
      case 0x04: // GET_VARIANT_NAME
        this.parseVariantName(payload)
        break
      default:
         this.addParseResult(`未知V3命令: 0x${commandId.toString(16).padStart(2, '0')}`)
    }
  },

  // 解析GAIA版本（与Android GaiaVersionData和V2ApiVersion一致）
  parseGaiaVersion(payload) {
    console.log(`📋 [GAIA版本] 原始数据: ${Array.from(payload).map(b => '0x' + b.toString(16).padStart(2, '0')).join(' ')}`)
    
    if (payload && payload.length >= 1) {
      let gaiaVersion, versionText
      
      if (payload.length >= 3) {
        // V2ApiVersion格式：3字节 [协议版本, API主版本, API次版本]
        const protocolVersion = payload[0]  // 协议版本
        const apiVersionMajor = payload[1]  // API主版本 = GAIA版本
        const apiVersionMinor = payload[2]  // API次版本
        
        gaiaVersion = apiVersionMajor
        versionText = `GAIA V${gaiaVersion} (协议V${protocolVersion}, API ${apiVersionMajor}.${apiVersionMinor})`
        
        console.log(`📋 [GAIA版本] V2ApiVersion格式: 协议V${protocolVersion}, GAIA V${gaiaVersion}, API ${apiVersionMajor}.${apiVersionMinor}`)
      } else {
        // GaiaVersionData格式：1字节 [GAIA版本]
        gaiaVersion = payload[0]
        versionText = `GAIA V${gaiaVersion}`
        
        console.log(`📋 [GAIA版本] GaiaVersionData格式: GAIA V${gaiaVersion}`)
      }
      
      // ✅ 修复：确保gaiaVersion不为0时才设置数据
      if (gaiaVersion > 0) {
        this.setData({
          'deviceInfo.gaiaVersion': versionText,
          'deviceInfo.hasVersions': true
        })
        
        // 缓存GAIA版本
        this.updateStoredDeviceInfo('gaiaVersion', versionText)
        
        this.addParseResult(`GAIA版本: ${versionText}`)
      } else {
        console.log(`📋 [GAIA版本] 版本号为0，可能是解析错误`)
        this.addParseResult(`GAIA版本: 解析错误 (版本号: ${gaiaVersion})`)
      }
    } else {
      console.log('📋 [GAIA版本] 数据为空或长度不足')
      this.addParseResult('GAIA版本: 无数据')
    }
  },

  // 解析应用版本
  parseApplicationVersion(payload) {
    if (payload && payload.length >= 2) {
      const major = payload[0]
      const minor = payload[1]
      const versionText = `${major}.${minor}`
      
      this.setData({
        'deviceInfo.applicationVersion': versionText,
        'deviceInfo.hasVersions': true
      })
      
       this.addParseResult(`应用版本: ${versionText}`)
    }
  },

  // 解析序列号
  parseSerialNumber(payload) {
    if (payload && payload.length > 0) {
      const serialNumber = String.fromCharCode(...payload).replace(/\0/g, '')
      
      this.setData({
        'deviceInfo.serialNumber': serialNumber,
        'deviceInfo.hasSerialNumbers': true
      })
      
      // 缓存序列号
      this.updateStoredDeviceInfo('serialNumber', serialNumber)
      
       this.addParseResult(`序列号: ${serialNumber}`)
    }
  },

  // 解析变体名称
  parseVariantName(payload) {
    if (payload && payload.length > 0) {
      const variantName = String.fromCharCode(...payload).replace(/\0/g, '')
      
      this.setData({
        'deviceInfo.variantName': variantName
      })
      
      // 缓存变体名称
      this.updateStoredDeviceInfo('variantName', variantName)
      
       this.addParseResult(`变体名称: ${variantName}`)
    }
  },

  // 解析蓝牙地址
  parseBluetoothAddress(payload) {
    if (payload && payload.length >= 6) {
      const address = payload.slice(0, 6).map(b => b.toString(16).padStart(2, '0')).join(':').toUpperCase()
      
      this.setData({
        'deviceInfo.bluetoothAddress': address
      })
      
       this.addParseResult(`蓝牙地址: ${address}`)
    }
  },

  // 解析系统信息
  parseSystemInformation(payload) {
    if (payload && payload.length > 0) {
      const info = String.fromCharCode(...payload).replace(/\0/g, '')
      
       this.addParseResult(`系统信息: ${info}`)
    }
  },

  // 解析支持的电池类型（保留以备后用）
  parseSupportedBatteries(payload) {
    console.log(`🔋 [支持的电池类型] 原始数据: ${Array.from(payload).map(b => '0x' + b.toString(16).padStart(2, '0')).join(' ')}`)
    
    if (payload && payload.length > 0) {
      const supportedBatteries = Array.from(payload).map(batteryType => {
        console.log(`🔋 [支持的电池类型] 解析电池类型: 0x${batteryType.toString(16).padStart(2, '0')}`)
        switch (batteryType) {
          case 0: return '单设备'
          case 1: return '左耳'
          case 2: return '右耳'
          case 3: return '充电盒'
          default: return `未知类型(${batteryType})`
        }
      })
      
      console.log(`🔋 [支持的电池类型] 解析结果: ${supportedBatteries.join(', ')}`)
      
      this.setData({
        'deviceInfo.supportedBatteries': supportedBatteries
      })
      
      this.addParseResult(`支持的电池类型: ${supportedBatteries.join(', ')}`)
    } else {
      console.log('🔋 [支持的电池类型] 数据为空或长度为0')
      this.addParseResult('支持的电池类型: 无数据')
    }
  },

  // 解析电池电量
  parseBatteryLevels(payload) {
    if (payload && payload.length >= 1) {  // ✅ 修复：支持单字节返回
      const batteryLevels = {}
      
      if (payload.length >= 2) {
        // 标准格式：[电池类型][电量百分比]
        for (let i = 0; i < payload.length; i += 2) {
          if (i + 1 < payload.length) {
            const batteryType = payload[i]
            const level = payload[i + 1]
            
            let typeName = ''
            switch (batteryType) {
              case 0: typeName = 'device'; break
              case 1: typeName = 'left'; break
              case 2: typeName = 'right'; break
              case 3: typeName = 'case'; break
              default: typeName = `unknown_${batteryType}`; break
            }
            
            batteryLevels[typeName] = level === 0xFF ? null : level
          }
        }
      } else if (payload.length === 1) {
        // 单字节格式：只有电量值，默认为单设备
        const level = payload[0]
        batteryLevels['device'] = level === 0xFF ? null : level
        console.log(`🔋 [电池解析] 单字节格式，电量: ${level}%`)
      }
      
      this.setData({
        'deviceInfo.batteryLevels': batteryLevels,
        'deviceInfo.hasBatteryLevels': true
      })
      
      this.addParseResult(`电池电量: ${JSON.stringify(batteryLevels)}`)
    }
  },

  // 解析充电器状态
  parseChargerStatus(payload) {
    if (payload && payload.length > 0) {
      const isCharging = payload[0] === 1
      
      this.setData({
        'deviceInfo.isCharging': isCharging,
        'deviceInfo.hasStates': true
      })
      
       this.addParseResult(`充电状态: ${isCharging ? '充电中' : '未充电'}`)
    }
  },

  // 添加解析结果到页面数据
  addParseResult(message) {
    const parseResults = this.data.deviceInfo.parseResults || []
    
    // 根据消息内容确定样式类
    const styleClass = this.getMessageStyleClass(message)
    
    const newResult = {
      time: new Date().toLocaleTimeString(),
      message: message,
      styleClass: styleClass
    }
    
    parseResults.push(newResult)
    
    // 只保留最近20条记录
    if (parseResults.length > 20) {
      parseResults.splice(0, parseResults.length - 20)
    }
    
    console.log(`📊 [解析结果] 添加: ${message}, 总数: ${parseResults.length}`)
    
    this.setData({
      'deviceInfo.parseResults': parseResults
    })
  },

  // 根据消息内容确定样式类
  getMessageStyleClass(message) {
    if (message.includes('✅')) {
      return 'success'
    } else if (message.includes('⚠️')) {
      return 'warning'
    } else if (message.includes('❌')) {
      return 'error'
    } else if (message.includes('📋')) {
      return 'info-blue'
    } else if (message.includes('📱')) {
      return 'info-purple'
    } else if (message.includes('🔢')) {
      return 'info-cyan'
    } else if (message.includes('🏷️')) {
      return 'info-pink'
    } else if (message.includes('📡')) {
      return 'info-orange'
    } else if (message.includes('🔋')) {
      return 'info-green'
    } else if (message.includes('🔌')) {
      return 'info-yellow'
    } else if (message.includes('ℹ️')) {
      return 'info-blue'
    }
    return 'default'
  },


  // Android兼容的字符串解析方法（完全基于BytesUtils.getString）
  parseAndroidString(data, vendorId = null) {
    // ✅ 完全匹配Android BytesUtils.getString方法
    if (!data || data.length === 0) {
       return ""
    }

 
    // ✅ 根据协议版本采用不同的解析策略
    let actualData = data
    
    // V3协议：直接使用数据，不处理状态码（匹配Android V3BasicPlugin逻辑）
    if (vendorId === VendorID.QTIL_V3) {
       actualData = data
    } else {
      // V1/V2协议：处理状态码（保持原有逻辑）
       if (data.length > 0) {
        // 检查第一个字节是否为状态码
        const statusCode = data[0]
         
        // 根据Android V1V2ErrorStatus枚举处理状态码
        switch (statusCode) {
          case 0x00: // SUCCESS
             if (data.length > 1) {
              actualData = data.slice(1)
              } else {
               return ""
            }
            break
          case 0x01: // COMMAND_NOT_SUPPORTED
             return "命令不支持"
          case 0x02: // NOT_AUTHENTICATED
             return "未认证"
          case 0x03: // INSUFFICIENT_RESOURCES
             return "资源不足"
          case 0x04: // AUTHENTICATING
             return "认证中"
          case 0x05: // INVALID_PARAMETER
             return "无效参数"
          case 0x06: // INCORRECT_STATE
             return "状态错误"
          case 0x07: // IN_PROGRESS
             return "处理中"
          default:
             return "未知状态"
        }
      }
    }

    // ✅ 完全匹配Android BytesUtils.getString方法
    let result = ""

    try {
      // 直接使用UTF-8解码（匹配Android StandardCharsets.UTF_8）
      result = this.decodeUtf8(actualData)
     } catch (exception) {
       // Android在异常时返回空字符串，不尝试其他方法
      result = ""
    }

     return result
  },

  // UTF-8解码辅助函数（兼容微信小程序）
  decodeUtf8(bytes) {
    if (!bytes || bytes.length === 0) return ''
    
    let result = ''
    let i = 0
    
    while (i < bytes.length) {
      let byte1 = bytes[i++]
      
      if (byte1 < 0x80) {
        // 单字节字符 (ASCII)
        result += String.fromCharCode(byte1)
      } else if ((byte1 >> 5) === 0x06) {
        // 双字节字符
        if (i < bytes.length) {
          let byte2 = bytes[i++]
          result += String.fromCharCode(((byte1 & 0x1F) << 6) | (byte2 & 0x3F))
        }
      } else if ((byte1 >> 4) === 0x0E) {
        // 三字节字符
        if (i + 1 < bytes.length) {
          let byte2 = bytes[i++]
          let byte3 = bytes[i++]
          result += String.fromCharCode(((byte1 & 0x0F) << 12) | ((byte2 & 0x3F) << 6) | (byte3 & 0x3F))
        }
      } else if ((byte1 >> 3) === 0x1E) {
        // 四字节字符
        if (i + 2 < bytes.length) {
          let byte2 = bytes[i++]
          let byte3 = bytes[i++]
          let byte4 = bytes[i++]
          result += String.fromCharCode(((byte1 & 0x07) << 18) | ((byte2 & 0x3F) << 12) | ((byte3 & 0x3F) << 6) | (byte4 & 0x3F))
        }
      }
    }
    
    return result
  },

  // 处理设备数据
  handleDeviceData(commandId, payload, type, vendorId = null) {
    try {
      // 添加响应去重机制
      const responseKey = `${commandId}_${vendorId}_${JSON.stringify(payload)}_${type}`
      if (this.processedResponses && this.processedResponses.has(responseKey)) {
        console.log(`🔄 [去重] 跳过重复响应: commandId=${commandId}, vendorId=${vendorId}`)
        return // 已经处理过这个响应，跳过
      }
      
      if (!this.processedResponses) {
        this.processedResponses = new Set()
      }
      this.processedResponses.add(responseKey)
      
      // 将commandId转换为十六进制格式
      const hexCommandId = typeof commandId === 'number' ? commandId : parseInt(commandId, 16)
 
      
      // 根据Vendor ID和Command ID确定具体的命令类型
      let actualCommand = null
      if (vendorId === VendorID.QTIL_V3) {
        // V3插件（电池相关 + 基础功能）
        if (hexCommandId === 0x00) {
          // 特殊处理：0x00命令既可能是GET_GAIA_VERSION也可能是GET_SUPPORTED_BATTERIES
 
          
          // 根据payload内容智能判断
          if (payload && payload.length === 2 && payload[0] >= 1 && payload[0] <= 5 && payload[1] >= 0 && payload[1] <= 5) {
            // GAIA版本响应：2个字节，第一个字节是GAIA版本(1-5)，第二个字节是协议版本(0-5)
             actualCommand = 'GET_GAIA_VERSION'
          } else if (payload && payload.length === 1 && payload[0] >= 1 && payload[0] <= 5) {
            // GAIA版本响应：单个字节版本号
             actualCommand = 'GET_GAIA_VERSION'
          } else if (payload && payload.length > 2 && payload.every(b => b >= 0 && b <= 3)) {
            // 明确的电池类型数组：多个字节且都在0-3范围内
             actualCommand = 'GET_SUPPORTED_BATTERIES'
          } else {
            // 其他情况都优先识别为GET_GAIA_VERSION
             actualCommand = 'GET_GAIA_VERSION'
          }
        }
        else if (hexCommandId === 0x01) actualCommand = 'GET_BATTERY_LEVELS'
        else if (hexCommandId === 0x02) actualCommand = 'GET_CHARGER_STATUS'
        else if (hexCommandId === 0x03) actualCommand = 'GET_SERIAL_NUMBER'
        else if (hexCommandId === 0x04) actualCommand = 'GET_VARIANT_NAME'
        else if (hexCommandId === 0x05) actualCommand = 'GET_APPLICATION_VERSION'
        else if (hexCommandId === 0x10) actualCommand = 'GET_DEVICE_BLUETOOTH_ADDRESS'
        else if (hexCommandId === 0x11) actualCommand = 'GET_SYSTEM_INFORMATION'
        else if (hexCommandId === 0x20) actualCommand = 'GET_EARBUD_POSITION'
        else if (hexCommandId === 0x21) actualCommand = 'GET_SECONDARY_SERIAL_NUMBER'
        else if (hexCommandId === 0x30) actualCommand = 'GET_USER_FEATURES'
      } else if (vendorId === VendorID.QTIL_V1V2) {
        // V1V2插件（基础功能）
        if (hexCommandId === 0x00) actualCommand = 'GET_GAIA_VERSION'
        else if (hexCommandId === 0x05) actualCommand = 'GET_APPLICATION_VERSION'
        else if (hexCommandId === 0x03) actualCommand = 'GET_SERIAL_NUMBER'
        else if (hexCommandId === 0x04) actualCommand = 'GET_VARIANT_NAME'
        else if (hexCommandId === 0x10) actualCommand = 'GET_DEVICE_BLUETOOTH_ADDRESS'
        else if (hexCommandId === 0x11) actualCommand = 'GET_SYSTEM_INFORMATION'
      }
       // 根据实际命令类型处理数据
      switch (actualCommand) {
        case 'GET_GAIA_VERSION':
          // 📋 处理GAIA协议版本响应 (命令0x00, Vendor ID: 0x000A)
          // 🔍 Android对应：GaiaVersionData.java 和 V2ApiVersion.java
          // 📊 数据解析：支持两种格式
          //   1. GaiaVersionData: payload[0] = GAIA版本号
          //   2. V2ApiVersion: payload[0,1,2] = [协议版本, API主版本, API次版本]
          // 🎯 用途：确定设备支持的GAIA协议版本，影响后续命令兼容性
          this.parseGaiaVersion(payload)
          break
          
        case 'GET_DEVICE_BLUETOOTH_ADDRESS':
          // 📋 处理设备蓝牙地址响应 (命令0x10)
          // 🔍 Android对应：通常直接从BluetoothDevice.getAddress()获取，GAIA命令为备用方案
          // 📊 数据解析：6字节MAC地址转换为XX:XX:XX:XX:XX:XX格式
          // 🎯 用途：显示设备蓝牙地址，用于设备识别、配对管理、问题诊断
          if (payload && payload.length >= 6) {
            // 将6字节MAC地址转换为标准格式
            const macAddress = Array.from(payload.slice(0, 6))
              .map(byte => byte.toString(16).padStart(2, '0').toUpperCase())
              .join(':')
            
            this.setData({
              'deviceInfo.bluetoothAddress': macAddress,
              'deviceInfo.hasVersions': true
            })
           }
          break
          
        case 'GET_APPLICATION_VERSION':
          // 📋 处理设备固件版本响应 (命令0x05)
          // 🔍 Android对应：TextData.java - getText()返回UTF-8版本字符串
          // 📊 数据解析：字节数组转换为UTF-8字符串，格式通常为"主.次.补丁.构建号"
          // 🎯 用途：显示设备固件版本，用于版本检查、升级判断、问题诊断
          if (payload && payload.length > 0) {
            // 使用Android兼容的字符串解析方法，传入vendorId以区分协议版本
            const versionString = this.parseAndroidString(payload, vendorId)
            const buildId = versionString.split('.').pop() || ''
            
            this.setData({
              'deviceInfo.applicationVersion': versionString,
              'deviceInfo.applicationBuildId': buildId,
              'deviceInfo.hasVersions': true
            })
            
            // 缓存应用版本和构建ID
            this.updateStoredDeviceInfo('applicationVersion', versionString)
            this.updateStoredDeviceInfo('applicationBuildId', buildId)
           }
          break
          
        case 'GET_BATTERY_LEVELS':
          // 📋 处理电池电量响应 (命令0x01) - 与Android版本BatteryLevel.buildSet()完全一致
          // 🔍 Android对应：V3BatteryPlugin.onBatteryLevels() -> BatteryLevel.buildSet()
          // 📊 数据解析：每2字节一组 [电池类型][电量百分比]，0xFF表示未知电量
          // 🎯 用途：显示各电池电量，支持单设备、左右耳、充电盒等多种电池类型
          if (payload && payload.length >= 2) {
             
            // 使用gaiaManager的解析方法（与Android版本一致）
            const batteryResult = gaiaManager.parseBatteryLevels(payload)
            
            if (batteryResult.error) {
               return
            }
            
            // 更新UI数据
            this.setData({
              'deviceInfo.batteryLevels': batteryResult.levels,
              'deviceInfo.hasBatteryLevels': batteryResult.count > 0
            })
            
            // 输出详细的电池信息（与Android版本对应）
             Object.entries(batteryResult.levels).forEach(([batteryName, level]) => {
              if (level !== null) {
               } else {
               }
            })
          }
          break
          
        case 'GET_SERIAL_NUMBER':
          if (payload && payload.length > 0) {
            // 使用Android兼容的字符串解析方法
            const serialNumber = this.parseAndroidString(payload, vendorId)
            
            this.setData({
              'deviceInfo.serialNumber': serialNumber,
              'deviceInfo.hasSerialNumbers': true
            })
           }
          break
          
        case 'GET_VARIANT_NAME':
          // 📋 处理设备变体名称响应 (命令0x04)
          // 🔍 Android对应：TextData.java - getText()返回UTF-8变体名称字符串
          // 📊 数据解析：字节数组转换为UTF-8字符串，移除空字节
          // 🎯 用途：显示设备变体名称，用于设备型号识别
          if (payload && payload.length > 0) {
            // 使用Android兼容的字符串解析方法
            const variantName = this.parseAndroidString(payload, vendorId)
            
            this.setData({
              'deviceInfo.variantName': variantName,
              'deviceInfo.hasVersions': true
            })
           }
          break
          
        case 'GET_SYSTEM_INFORMATION':
          // 📋 处理系统信息响应 (命令0x11)
          // 🔍 Android对应：SystemInformationData.java - 解析系统信息
          // 📊 数据解析：包含设备的各种系统信息
          // 🎯 用途：显示设备系统信息，用于设备状态诊断
          if (payload && payload.length > 0) {
            // 使用Android兼容的字符串解析方法
            const systemInfo = this.parseAndroidString(payload, vendorId)
            this.setData({
              'deviceInfo.systemInformation': systemInfo,
              'deviceInfo.hasVersions': true
            })
           }
          break
          
        default:
       }
    } catch (error) {
     }
  },

  // 跳转到设备发现页面
  goToDiscovery() {
     wx.navigateTo({
      url: '/pages/discovery/discovery'
    })
  },


 

     // 获取电池电量
   async getBatteryLevels(retryCount = 0, maxRetries = 3) {
    //  console.log('🔋 获取电池电量11111111111111111')
     
    //  try {
    //    // 检查连接状态
    //    if (!gaiaManager.isConnected) {
    //      return null
    //    }
       
    //          // 1. 获取支持的电池类型（Android: fetchSupportedBatteries）
    //   const supportedResult = await gaiaManager.sendCommand(GaiaCommand.GET_SUPPORTED_BATTERIES, [])
    //   console.log('📋 支持的电池类型响应:', supportedResult)
      
    //   let supportedBatteries = []
    //   if (supportedResult.success && supportedResult.payload) {
    //     // 使用gaiaManager的解析方法（与Android版本一致）
    //     const supportedData = gaiaManager.parseSupportedBatteries(supportedResult.payload)
    //     if (!supportedData.error) {
    //       supportedBatteries = supportedData.supported
    //       console.log(`📋 支持的电池类型: ${supportedData.supportedBatteries.map(b => b.name).join(', ')}`)
    //     }
    //   } else {
    //     // 默认查询所有类型（Android: 如果获取失败则查询所有）
    //     supportedBatteries = [0x00, 0x01, 0x02, 0x03] // Battery枚举值
    //     console.log('📋 使用默认电池类型查询')
    //   }
      
    //   if (supportedBatteries.length === 0) {
    //     console.warn('📋 没有支持的电池类型')
    //     return null
    //   }
      
    //   // 2. 获取电池电量（Android: fetchBatteryLevels）
    //   const payload = new Uint8Array(supportedBatteries)
    //   const batteryResult = await gaiaManager.sendCommand(GaiaCommand.GET_BATTERY_LEVELS, payload)
    //   console.log('📋 电池电量响应:', batteryResult)
      
    //   if (batteryResult.success && batteryResult.payload) {
    //     // 3. 使用gaiaManager解析电池电量数据（与Android版本一致）
    //     const batteryData = gaiaManager.parseBatteryLevels(batteryResult.payload)
        
    //     if (batteryData.error) {
    //       console.error('📋 电池电量解析错误:', batteryData.error)
    //       // 解析错误时重试
    //       if (retryCount < 3) {
    //         console.log(`📋 解析错误，${1000}ms后重试...`)
    //         await new Promise(resolve => setTimeout(resolve, 1000))
    //         return this.getBatteryLevels(retryCount + 1, 3)
    //       }
    //       return null
    //     }
        
    //     console.log(`📋 成功获取 ${batteryData.count} 个电池的电量信息`)
    //     return batteryData.levels
        
    //   } else {
    //     console.warn('📋 获取电池电量失败')
    //     // 命令失败时重试
    //     if (retryCount < 3) {
    //       console.log(`📋 命令失败，${1000}ms后重试...`)
    //       await new Promise(resolve => setTimeout(resolve, 1000))
    //       return this.getBatteryLevels(retryCount + 1, 3)
    //     }
    //     return null
    //   }
       
    //  } catch (error) {
    //    console.error('📋 获取电池电量异常:', error)
    //    // 异常时重试
    //    if (retryCount < 3) {
    //      console.log(`📋 异常重试，${1000}ms后重试...`)
    //      await new Promise(resolve => setTimeout(resolve, 1000))
    //      return this.getBatteryLevels(retryCount + 1, 3)
    //    }
    //    return null
    //  }
   },

  // 处理GAIA版本响应
  handleGaiaVersionResponse(payload) {
    try {
      console.log('📋 [设备信息页面] 处理GAIA版本响应:', payload)
      
      if (payload && payload.length > 0) {
        // 解析GAIA版本数据
        const version = this.parseGaiaVersionData(payload)
        console.log('📋 [设备信息页面] 解析的GAIA版本:', version)
        
        // 更新UI
        this.setData({
          'deviceInfo.gaiaVersion': version,
          'deviceInfo.hasVersions': true
        })
        
        // 更新存储的设备信息
        this.updateStoredDeviceInfo('gaiaVersion', version)
      }
    } catch (error) {
      console.error('📋 [设备信息页面] 处理GAIA版本响应失败:', error)
    }
  },

  // 处理应用版本响应
  handleApplicationVersionResponse(payload) {
    try {
      console.log('📋 [设备信息页面] 处理应用版本响应:', payload)
      
      if (payload && payload.length > 0) {
        // 解析应用版本数据
        const versionData = this.parseApplicationVersionData(payload)
        console.log('📋 [设备信息页面] 解析的应用版本:', versionData)
        
        // 更新UI
        this.setData({
          'deviceInfo.applicationVersion': versionData.version,
          'deviceInfo.applicationBuildId': versionData.buildId,
          'deviceInfo.hasVersions': true
        })
        
        // 更新存储的设备信息
        this.updateStoredDeviceInfo('applicationVersion', versionData.version)
        this.updateStoredDeviceInfo('applicationBuildId', versionData.buildId)
      }
    } catch (error) {
      console.error('📋 [设备信息页面] 处理应用版本响应失败:', error)
    }
  },

  // 处理序列号响应
  handleSerialNumberResponse(payload) {
    try {
      console.log('📋 [设备信息页面] 处理序列号响应:', payload)
      
      if (payload && payload.length > 0) {
        // 解析序列号数据
        const serialNumber = this.parseSerialNumber(payload)
        console.log('📋 [设备信息页面] 解析的序列号:', serialNumber)
        
        // 更新UI
        this.setData({
          'deviceInfo.serialNumber': serialNumber,
          'deviceInfo.hasSerialNumbers': true
        })
        
        // 更新存储的设备信息
        this.updateStoredDeviceInfo('serialNumber', serialNumber)
      }
    } catch (error) {
      console.error('📋 [设备信息页面] 处理序列号响应失败:', error)
    }
  },

  // 处理变体名称响应
  handleVariantNameResponse(payload) {
    try {
      console.log('📋 [设备信息页面] 处理变体名称响应:', payload)
      
      if (payload && payload.length > 0) {
        // 解析变体名称数据
        const variantName = this.parseVariantName(payload)
        console.log('📋 [设备信息页面] 解析的变体名称:', variantName)
        
        // 更新UI
        this.setData({
          'deviceInfo.variantName': variantName
        })
        
        // 更新存储的设备信息
        this.updateStoredDeviceInfo('variantName', variantName)
      }
    } catch (error) {
      console.error('📋 [设备信息页面] 处理变体名称响应失败:', error)
    }
  },

  // 处理系统信息响应
  handleSystemInformationResponse(payload) {
    try {
      console.log('📋 [设备信息页面] 处理系统信息响应:', payload)
      
      if (payload && payload.length > 0) {
        // 解析系统信息数据
        const systemInfo = this.parseSystemInformation(payload)
        console.log('📋 [设备信息页面] 解析的系统信息:', systemInfo)
        
        // 更新UI和存储
        this.updateStoredDeviceInfo('systemInformation', systemInfo)
      }
    } catch (error) {
      console.error('📋 [设备信息页面] 处理系统信息响应失败:', error)
    }
  },

  // 处理电池电量响应
  handleBatteryLevelsResponse(payload) {
    try {
      console.log('📋 [设备信息页面] 处理电池电量响应:', payload)
      
      if (payload && payload.length > 0) {
        // 解析电池电量数据
        const batteryData = this.parseBatteryLevels(payload)
        console.log('📋 [设备信息页面] 解析的电池电量:', batteryData)
        
        // 更新UI
        this.setData({
          'deviceInfo.batteryLevels': batteryData,
          'deviceInfo.hasBatteryLevels': true
        })
        
        // 更新存储的设备信息
        this.updateStoredDeviceInfo('batteryLevels', batteryData)
      }
    } catch (error) {
      console.error('📋 [设备信息页面] 处理电池电量响应失败:', error)
    }
  },

  // 处理BLE原始数据
  handleBleData(data) {
    try {
      console.log('📋 [设备信息页面] 处理BLE原始数据:', data)
      
      // 更新UI显示BLE数据
      this.setData({
        'deviceInfo.bleData': data.value
      })
      
    } catch (error) {
      console.error('📋 [设备信息页面] 处理BLE数据失败:', error)
    }
  },

  // 解析GAIA版本（新方法，用于响应处理）
  parseGaiaVersionData(payload) {
    try {
      console.log('📋 [设备信息页面] 解析GAIA版本数据:', payload)
      
      // GAIA版本格式: [major(1字节), minor(1字节), patch(1字节)]
      if (payload && payload.length >= 1) {
        if (payload.length >= 3) {
          // V2ApiVersion格式：3字节 [协议版本, API主版本, API次版本]
          const protocolVersion = payload[0]  // 协议版本
          const apiVersionMajor = payload[1]  // API主版本 = GAIA版本
          const apiVersionMinor = payload[2]  // API次版本
          
          const gaiaVersion = apiVersionMajor
          const versionText = `GAIA V${gaiaVersion} (协议V${protocolVersion}, API ${apiVersionMajor}.${apiVersionMinor})`
          
          return versionText
        } else {
          // GaiaVersionData格式：1字节 [GAIA版本]
          const gaiaVersion = payload[0]
          const versionText = `GAIA V${gaiaVersion}`
          
          return versionText
        }
      }
      
      return '未知版本'
    } catch (error) {
      console.error('📋 [设备信息页面] 解析GAIA版本失败:', error)
      return '解析失败'
    }
  },

  // 解析应用版本（新方法，用于响应处理）
  parseApplicationVersionData(payload) {
    try {
      console.log('📋 [设备信息页面] 解析应用版本数据:', payload)
      
      // 尝试多种格式解析
      if (payload && payload.length >= 2) {
        // 格式1: [major(1字节), minor(1字节)] - 简单版本格式
        if (payload.length === 2) {
          const major = payload[0]
          const minor = payload[1]
          const version = `${major}.${minor}`
          return { version: version, buildId: 'N/A' }
        }
        
        // 格式2: [version(字符串), buildId(字符串)] - 字符串格式
        let offset = 0
        let version = ''
        let buildId = ''
        
        // 解析版本字符串
        while (offset < payload.length && payload[offset] !== 0) {
          version += String.fromCharCode(payload[offset])
          offset++
        }
        offset++ // 跳过null终止符
        
        // 解析构建ID字符串
        while (offset < payload.length && payload[offset] !== 0) {
          buildId += String.fromCharCode(payload[offset])
          offset++
        }
        
        return { 
          version: version || '未知版本', 
          buildId: buildId || '未知构建' 
        }
      }
      
      return { version: '无数据', buildId: '无数据' }
    } catch (error) {
      console.error('📋 [设备信息页面] 解析应用版本失败:', error)
      return { version: '解析失败', buildId: '解析失败' }
    }
  },

  // 解析序列号
  parseSerialNumber(payload) {
    try {
      // 序列号格式: 字符串
      let serialNumber = ''
      for (let i = 0; i < payload.length && payload[i] !== 0; i++) {
        serialNumber += String.fromCharCode(payload[i])
      }
      return serialNumber || '未知序列号'
    } catch (error) {
      console.error('📋 [设备信息页面] 解析序列号失败:', error)
      return '解析失败'
    }
  },

  // 解析变体名称
  parseVariantName(payload) {
    try {
      // 变体名称格式: 字符串
      let variantName = ''
      for (let i = 0; i < payload.length && payload[i] !== 0; i++) {
        variantName += String.fromCharCode(payload[i])
      }
      return variantName || '未知变体'
    } catch (error) {
      console.error('📋 [设备信息页面] 解析变体名称失败:', error)
      return '解析失败'
    }
  },

  // 解析系统信息
  parseSystemInformation(payload) {
    try {
      // 系统信息格式: [信息类型(1字节), 数据长度(1字节), 数据...]
      const systemInfo = {}
      let offset = 0
      
      while (offset < payload.length) {
        if (offset + 2 > payload.length) break
        
        const infoType = payload[offset]
        const dataLength = payload[offset + 1]
        offset += 2
        
        if (offset + dataLength > payload.length) break
        
        const data = payload.slice(offset, offset + dataLength)
        systemInfo[infoType] = data
        offset += dataLength
      }
      
      return systemInfo
    } catch (error) {
      console.error('📋 [设备信息页面] 解析系统信息失败:', error)
      return {}
    }
  },

  // 解析电池电量
  parseBatteryLevels(payload) {
    try {
      // 电池电量格式: [电池类型(1字节), 电量(1字节), ...]
      const batteryLevels = {
        device: null,
        left: null,
        right: null,
        case: null
      }
      
      for (let i = 0; i < payload.length; i += 2) {
        if (i + 1 >= payload.length) break
        
        const batteryType = payload[i]
        const level = payload[i + 1]
        
        switch (batteryType) {
          case 0x00: // 设备
            batteryLevels.device = level
            break
          case 0x01: // 左耳
            batteryLevels.left = level
            break
          case 0x02: // 右耳
            batteryLevels.right = level
            break
          case 0x03: // 充电盒
            batteryLevels.case = level
            break
        }
      }
      
      return batteryLevels
    } catch (error) {
      console.error('📋 [设备信息页面] 解析电池电量失败:', error)
      return { device: null, left: null, right: null, case: null }
    }
  },

  // 更新存储的设备信息
  updateStoredDeviceInfo(key, value) {
    try {
      const connectedDeviceInfo = wx.getStorageSync('connectedDeviceInfo') || {}
      connectedDeviceInfo[key] = value
      wx.setStorageSync('connectedDeviceInfo', connectedDeviceInfo)
      console.log(`📋 [设备信息页面] 更新存储信息: ${key} = ${value}`)
    } catch (error) {
      console.error('📋 [设备信息页面] 更新存储信息失败:', error)
    }
  },

  // 清除设备信息缓存
  clearDeviceInfoCache() {
    try {
      // 清除设备信息获取标记
      wx.removeStorageSync('deviceInfoFetched')
      console.log('📋 [设备信息页面] 设备信息缓存已清除')
    } catch (error) {
      console.error('📋 [设备信息页面] 清除设备信息缓存失败:', error)
    }
  }
})


